import { getCurrentConfig, buildApiUrl, validateConfig, loadConfigFromStorage } from '../config/apiConfig';

// API配置和服务
class ApiService {
  constructor() {
    // 尝试从本地存储加载配置
    loadConfigFromStorage();
    
    // 使用配置文件
    this.config = getCurrentConfig();
    
    // 验证配置
    validateConfig(this.config);
  }

  // 构建API URL - 使用配置文件中的函数
  buildApiUrl(message) {
    return buildApiUrl(message, this.config);
  }

  // 解析流式数据
  parseStreamData(dataString) {
    // 移除 "data:" 前缀
    if (dataString.startsWith('data:')) {
      dataString = dataString.substring(5);
    }
    
    // 清理数据字符串
    dataString = dataString.trim();
    
    try {
      return JSON.parse(dataString);
    } catch (e) {
      // 如果不是JSON，返回原始数据
      return { raw: dataString };
    }
  }

  // 流式API调用
  async streamChat(message, onData, onError, onComplete) {
    let attempts = 0;
    const maxAttempts = this.config.retry.attempts;
    
    while (attempts < maxAttempts) {
      try {
        const apiUrl = this.buildApiUrl(message);
        
        // 创建AbortController用于超时控制
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
        
        const response = await fetch(apiUrl, {
          method: 'GET',
          headers: this.config.headers,
          signal: controller.signal
        });
        
        clearTimeout(timeoutId);
        
        if (!response.ok) {
          throw new Error(`HTTP error! status: ${response.status}`);
        }
        
        const reader = response.body.getReader();
        const decoder = new TextDecoder();
        let buffer = '';
        
        // 处理流式数据
        while (true) {
          const { done, value } = await reader.read();
          
          if (done) {
            onComplete?.();
            break;
          }
          
          // 解码数据
          buffer += decoder.decode(value, { stream: true });
          
          // 按行分割数据
          const lines = buffer.split('\n');
          buffer = lines.pop(); // 保留最后一个不完整的行
          
          for (const line of lines) {
            if (line.trim() === '') continue;
            
            try {
              // 解析流式数据
              const data = this.parseStreamData(line);
              
              // 调用回调函数处理数据
              onData?.(data);
              
            } catch (e) {
              console.error('解析流式数据出错:', e);
            }
          }
        }
        
        // 处理最后一行数据
        if (buffer.trim()) {
          try {
            const data = this.parseStreamData(buffer);
            onData?.(data);
          } catch (e) {
            console.error('解析最后一行数据出错:', e);
          }
        }
        
        // 成功完成，跳出重试循环
        break;
        
      } catch (error) {
        attempts++;
        console.error(`API请求错误 (尝试 ${attempts}/${maxAttempts}):`, error);
        
        if (attempts >= maxAttempts) {
          // 达到最大重试次数，调用错误回调
          onError?.(error);
          break;
        } else {
          // 等待后重试
          await new Promise(resolve => setTimeout(resolve, this.config.retry.delay * attempts));
        }
      }
    }
  }

  // 智能检测和处理数据
  detectAndProcessData(data) {
    let foundData = false;
    
    // 1. 检查SqlExecuteNode格式
    if (data.node === "SqlExecuteNode" && data.data && data.data.data && data.data.data.records) {
      return {
        type: 'sqlExecute',
        data: data.data.data,
        found: true
      };
    }
    
    // 2. 直接的数据字段
    if (data.data && data.data.records) {
      return {
        type: 'records',
        data: data.data,
        found: true
      };
    }
    
    // 3. 数据字段直接是数组
    if (data.data && Array.isArray(data.data)) {
      return {
        type: 'array',
        data: { records: data.data },
        found: true
      };
    }
    
    // 4. 检查是否有records字段
    if (data.records && Array.isArray(data.records)) {
      return {
        type: 'directRecords',
        data: { records: data.records },
        found: true
      };
    }
    
    // 5. 检查整个数据对象是否包含查询结果
    if (data && typeof data === 'object') {
      for (const key in data) {
        if (Array.isArray(data[key]) && data[key].length > 0) {
          const firstItem = data[key][0];
          if (firstItem && typeof firstItem === 'object') {
            const hasQueryFields = Object.keys(firstItem).some(field => 
              field.includes('村') || field.includes('任务') || field.includes('完成') || 
              field.includes('率') || field.includes('进度') || field.includes('得分')
            );
            
            if (hasQueryFields) {
              return {
                type: 'queryResult',
                data: { records: data[key] },
                found: true
              };
            }
          }
        }
      }
    }
    
    return {
      type: 'none',
      data: null,
      found: false
    };
  }

  // 处理节点信息
  getNodeInfo(nodeName) {
    const nodeMap = {
      '__START__': {
        displayName: '开始处理',
        description: 'AI开始分析用户查询',
        icon: 'fas fa-play'
      },
      'SemanticRouterNode': {
        displayName: '语义路由',
        description: '分析查询意图，确定处理路径',
        icon: 'fas fa-route'
      },
      'IntentIdentificationNode': {
        displayName: '意图识别',
        description: '识别查询类型和业务意图',
        icon: 'fas fa-brain'
      },
      'GetGoldenSqlNode': {
        displayName: '获取参考SQL',
        description: '查找相似的SQL查询模板',
        icon: 'fas fa-search'
      },
      'GetTableNamesNode': {
        displayName: '获取表名',
        description: '确定查询涉及的数据表',
        icon: 'fas fa-table'
      },
      'TableRelationNode': {
        displayName: '表关系分析',
        description: '分析表之间的关联关系',
        icon: 'fas fa-project-diagram'
      },
      'SqlGeneratorNode': {
        displayName: 'SQL生成',
        description: '根据分析结果生成SQL语句',
        icon: 'fas fa-code'
      },
      'SqlExecuteNode': {
        displayName: 'SQL执行',
        description: '执行SQL查询，获取数据结果',
        icon: 'fas fa-database'
      },
      'ChartGenerationNode': {
        displayName: '图表生成',
        description: '根据数据生成可视化图表',
        icon: 'fas fa-chart-bar'
      },
      '__END__': {
        displayName: '处理完成',
        description: 'AI处理流程结束',
        icon: 'fas fa-check'
      }
    };
    
    return nodeMap[nodeName] || {
      displayName: nodeName,
      description: '处理节点',
      icon: 'fas fa-cog'
    };
  }
}

// 创建单例实例
const apiService = new ApiService();

export default apiService;
